package com.small.aop;

import java.lang.reflect.Method;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import com.small.proxy.Proxy;

/**
 * Aop缓存
 * @author 乐乐
 */
public class AopCache {
  
  /**
   * 类--代理对象的映射
   */
  public static Map<Class<?>, Object> classProxyCache = new ConcurrentHashMap<Class<?>, Object>();
  
  /**
   * 类--（方法--切面列表）的映射
   * 保证多线程安全
   */
  public static Map<Class<?>, Map<Method, List<Proxy>>> cache = new ConcurrentHashMap<Class<?>, Map<Method, List<Proxy>>>();
  
  /** 根据被缓存类获取当前类下使用切面代理的方法
   * @param clazz  被缓存类
   * @return Map集合   方法---方法切面列表
   */
  public static Map<Method, List<Proxy>> getCache(Class<?> clazz) {
    return cache.get(clazz);
  }
  
  /**
   * 新增aop映射入缓存
   * @param clazz  被缓存类
   * @param methodProxies   方法---方法切面列表
   */
  public static void setCache(Class<?> clazz, Map<Method, List<Proxy>> methodProxies) {
    cache.put(clazz, methodProxies);
  }
  
  /** 根据被缓存类获取当前类下使用切面代理的方法
   * @param clazz  被缓存类
   * @return 代理对象
   */
  public static Object getClassProxyCache(Class<?> clazz) {
    return classProxyCache.get(clazz);
  }
  
  /**
   * 新增aop映射入缓存
   * @param clazz  被缓存类
   * @param 代理对象
   */
  public static void setClassProxyCache(Class<?> clazz, Object proxy) {
    classProxyCache.put(clazz, proxy);
  }
  
}
